﻿#pragma once
#ifndef WRWORKOBJECT_H
#define WRWORKOBJECT_H

#include <QUuid>
#include "WRWorkEntity.h"
#include "WRWorkDealer.h"
#include "WRWorkSession.h"
#include "WRWorkObjectCollection.h"
#include "../WRSoft-Utility/Runtime/WRType.h"
#include "../WRSoft-Utility/Framing/WRTaskDealer.h"
#include "../WRSoft-Utility/Framing/WRDataSource.h"
#include "../WRSoft-Utility/Framing/WREventSource.h"
#include "../WRSoft-Utility/Framing/WRStateSource.h"

//表示工作对象类。
class WRSOFT_WORKING_COMMON_CLASS WRWorkObject : public WRWorkEntity
{
    friend class WRWorkDaemon;
    friend class WRWorkModule;
    friend class WRWorkSession;

public:
    //获取当前工作对象类型。
    virtual WRType* type(void) const = 0;

    //查询指定标识的工作处理者。
    virtual WRWorkDealer* queryWorkDealer(const QUuid &uuid);
    //查询指定标识的任务处理者。
    virtual WRTaskDealer* queryTaskDealer(const QUuid& uuid);
    //查询指定标识的数据源接口。
    virtual WRDataSource* queryDataSource(const QUuid& uuid);
    //查询指定标识的事件源接口。
    virtual WREventSource* queryEventSource(const QUuid& uuid);
    //查询指示标识的状态源接口。
    virtual WRStateSource* queryStateSource(const QUuid& uuid);

private:
    //所属工作域。
    WRWorkDaemon* m_daemon;
    //所属工作会话。
    WRWorkSession* m_session;
    //所属父工作对象。
    WRWorkObject* m_parent;
    //子工作对象集合。
    WRWorkObjectCollection m_children;

    //禁用复制构造函数和赋值操作符。
    Q_DISABLE_COPY(WRWorkObject)

protected:
    //当加载后执行相应的初始工作。
    virtual void onInit(void);
    //当删除前执行相应的清理工作。
    virtual void onFree(void);

    //设置子工作对象集合。
    inline void setChildren(const WRWorkObjectCollection& value)
    {
        m_children = value;
    }
    //设置子工作对象集合。
    inline void setChildren(const QList<WRWorkObject*>& value)
    {
        m_children = WRWorkObjectCollection(value);
    }
    //设置子工作对象集合。
    inline void setChildren(const WRArray<WRWorkObject*>& value)
    {
        m_children = WRWorkObjectCollection(value);
    }

    //初始化工作对象。
    WRWorkObject(const WRWorkInformation& info, WRWorkObject* parent);
    //初始化工作对象。
    WRWorkObject(const WRWorkInformation& info, WRWorkDaemon* daemon);
    //初始化工作对象。
    WRWorkObject(const WRWorkInformation& info, WRWorkSession* session);

    //清理当前对象所占用的相关资源。
    ~WRWorkObject();

public:
    //添加对象引用。
    inline void addRef(void)
    {
        if (m_session)
        {
            m_session->addRef();
        }
        else
        {
            m_daemon->addRef();
        }
    }
    //释放对象引用, 如果引用计数为0，则删除对象，返回True，否则返回False。
    inline bool release(void)
    {
        if (m_session)
        {
            return m_session->release();
        }
        else
        {
            return m_daemon->release();
        }
    }

    //获取一个值，该值标识当前工作对象是否本地工作对象。
    inline bool local(void) const
    {
        return !m_session;
    }

    //获取包含当前工作对象的工作进程。
    inline WRWorkDaemon* daemon(void) const
    {
        return m_daemon;
    }
    //获取包含当前工作对象的工作域，如果是本地对象，则返回0。
    inline WRWorkDomain* domain(void) const
    {
        if (m_session)
        {
            return m_session->domain();
        }
        return 0;
    }
    //获取包含当前工作对象的会话，如果是本地对象，则返回0。
    inline WRWorkSession* session(void) const
    {
        return m_session;
    }

    //所属父工作对象。
    inline WRWorkObject* parent(void) const
    {
        return m_parent;
    }
    //子工作对象集合。
    const WRWorkObjectCollection& children() const
    {
        return m_children;
    }

    //识别当前对象是否是指定类型标识对象的实例。
    inline bool identify(const QUuid& tuid) const
    {
        WRType* type = this->type();
        while(type)
        {
            if (type->uuid() == tuid)
            {
                return true;
            }
            type = type->base();
        }
        return false;
    }
    //识别当前对象是否是指定类型对象的实例。
    inline bool identify(WRType* type) const
    {
        if (type)
        {
            WRType* type2 = this->type();
            while(type2)
            {
                if (type2 == type)
                {
                    return true;
                }
                type2 = type2->base();
            }
        }
        return false;
    }
};

#endif // WRWORKOBJECT_H
